{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f1a53f54",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "#  12\\.  K 近邻算法实现与应用  # \n",
    "\n",
    "##  12.1.  介绍  # \n",
    "\n",
    "在解决分类问题的过程中，K 近邻算法（简称：KNN）是一种简单而且实用的方法。本次实验将对 K 近邻算法进行详细的介绍，并从距离计算，分类决策等方面熟悉 K 近邻算法的原理及 Python 实现，最后，运用 K 近邻算法构建预测模型，并实现对丁香花分类。 \n",
    "\n",
    "##  12.2.  知识点  # \n",
    "\n",
    "  * 最近邻算法 \n",
    "\n",
    "  * K 近邻算法 \n",
    "\n",
    "  * 决策规则 \n",
    "\n",
    "  * KNN 算法实现 \n",
    "\n",
    "##  12.3.  最近邻算法  # \n",
    "\n",
    "介绍 K 近邻算法之前，首先说一说最近邻算法。最近邻算法（Nearest Neighbor，简称：NN），其针对未知类别数据  $x$  ，在训练集中找到与  $x$  最相似的训练样本  $y$  ，用  $y$  的样本对应的类别作为未知类别数据  $x$  的类别，从而达到分类的效果。 \n",
    "\n",
    "![image](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710607620.png)\n",
    "\n",
    "如上图所示，通过计算数据  $X_{u}$  （未知样本）和已知类别  ${\\omega_{1},\\omega_{2},\\omega_{3}}$  （已知样本）之间的距离，判断  $X_{u}$  与不同训练集的相似度，最终判断  $X_{u}$  的类别。显然，这里将  绿色未知样本  类别判定与  红色已知样本  类别相同较为合适。 \n",
    "\n",
    "##  12.4.  K 近邻算法  # \n",
    "\n",
    "K 近邻（K-Nearest Neighbors，简称：KNN）算法是最近邻（NN）算法的一个推广，也是机器学习分类算法中最简单的方法之一。KNN 算法的核心思想和最近邻算法思想相似，都是通过寻找和未知样本相似的类别进行分类。但 NN 算法中只依赖 1 个样本进行决策，在分类时过于绝对，会造成分类效果差的情况，为解决 NN 算法的缺陷，KNN 算法采用 K 个相邻样本的方式共同决策未知样本的类别,这样在决策中容错率相对于 NN 算法就要高很多，分类效果也会更好。 \n",
    "\n",
    "[ ![https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710607860.jpg](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710607860.jpg) ](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710607860.jpg)\n",
    "\n",
    "如上图所示，对于未知测试样本（图中  ？  所示）采用 KNN 算法进行分类，首先计算未知样本和训练样本之间的相似度，找出最近 K 个相邻样本（在图中 K 值为 3，圈定距离 ？最近的 3 个样本），再根据最近的 K 个样本最终判断未知样本的类别。 \n",
    "\n",
    "##  12.5.  K 近邻算法实现  # \n",
    "\n",
    "KNN 算法在理论上已经非常成熟，其简单、易于理解的思想以及良好的分类准确度使得 KNN 算法应用非常广泛。算法的具体流程主要是以下的 4 个步骤： \n",
    "\n",
    "  1. 数据准备：通过数据清洗，数据处理，将每条数据整理成向量。 \n",
    "\n",
    "  2. 计算距离：计算测试数据与训练数据之间的距离。 \n",
    "\n",
    "  3. 寻找邻居：找到与测试数据距离最近的 K 个训练数据样本。 \n",
    "\n",
    "  4. 决策分类：根据决策规则，从 K 个邻居得到测试数据的类别。 \n",
    "\n",
    "![image](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid7506timestamp1553223795293.png)\n",
    "\n",
    "下面，我们尝试完成一个 KNN 分类流程。首先，生成一组示例数据，共包含 2 个类别  $A$  和  $B$  ，其中每一条数据包含两个特征  $x$  和  $y$  。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "8728a9d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def create_data():\n",
    "    features = np.array(\n",
    "        [\n",
    "            [2.88, 3.05],\n",
    "            [3.1, 2.45],\n",
    "            [3.05, 2.8],\n",
    "            [2.9, 2.7],\n",
    "            [2.75, 3.4],\n",
    "            [3.23, 2.9],\n",
    "            [3.2, 3.75],\n",
    "            [3.5, 2.9],\n",
    "            [3.65, 3.6],\n",
    "            [3.35, 3.3],\n",
    "        ]\n",
    "    )\n",
    "    labels = [\"A\", \"A\", \"A\", \"A\", \"A\", \"B\", \"B\", \"B\", \"B\", \"B\"]\n",
    "    return features, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ce32077",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "然后，我们尝试加载并打印这些数据。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "db4477d6",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "features: \n",
      " [[2.88 3.05]\n",
      " [3.1  2.45]\n",
      " [3.05 2.8 ]\n",
      " [2.9  2.7 ]\n",
      " [2.75 3.4 ]\n",
      " [3.23 2.9 ]\n",
      " [3.2  3.75]\n",
      " [3.5  2.9 ]\n",
      " [3.65 3.6 ]\n",
      " [3.35 3.3 ]]\n",
      "labels: \n",
      " ['A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'B']\n"
     ]
    }
   ],
   "source": [
    "features, labels = create_data()\n",
    "print(\"features: \\n\", features)\n",
    "print(\"labels: \\n\", labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68c8b117",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "为了更直观地理解数据，接下来用 Matplotlib 下的 pyplot 包来对数据集进行可视化。为了代码的简洁，我们使用了 ` map  ` 函数和 ` lambda  ` 表达式对数据进行处理。如果你对这两个方法不太了解，需要自学相应的 Python 知识。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a50a9dcb",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x15dfd8bef50>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.figure(figsize=(5, 5))\n",
    "plt.xlim((2.4, 3.8))\n",
    "plt.ylim((2.4, 3.8))\n",
    "\n",
    "x_feature = list(map(lambda x: x[0], features))  # 返回每个数据的x特征值\n",
    "y_feature = list(map(lambda y: y[1], features))\n",
    "\n",
    "plt.scatter(x_feature[:5], y_feature[:5], c=\"b\")  # 在画布上绘画出\"A\"类标签的数据点\n",
    "plt.scatter(x_feature[5:], y_feature[5:], c=\"g\")\n",
    "plt.scatter([3.18], [3.15], c=\"r\", marker=\"x\")  # 待测试点的坐标为 [3.1，3.2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14d58f45",
   "metadata": {},
   "source": [
    "------**以下是上段代码的解释**------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "556e802e",
   "metadata": {},
   "source": [
    "这段代码使用 Matplotlib 绘制了一个二维平面上的散点图，展示了两类数据点（A 类和 B 类）以及一个待测试点。以下是代码的详细解释和 `map` 与 `lambda` 表达式的用法说明。\n",
    "\n",
    "---\n",
    "\n",
    "### 1. **导入 Matplotlib**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0ece7d4",
   "metadata": {},
   "source": [
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faf0b3ed",
   "metadata": {},
   "source": [
    "- **`from matplotlib import pyplot as plt`**：导入 Matplotlib 的绘图模块 `pyplot`，用于绘制图形。\n",
    "- **`%matplotlib inline`**：这是 Jupyter Notebook 的魔法命令，用于在 Notebook 中直接显示绘图结果。\n",
    "\n",
    "---\n",
    "\n",
    "### 2. **设置画布大小和坐标范围**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d09fe9f7",
   "metadata": {},
   "source": [
    "plt.figure(figsize=(5, 5))\n",
    "plt.xlim((2.4, 3.8))\n",
    "plt.ylim((2.4, 3.8))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21c17fa4",
   "metadata": {},
   "source": [
    "- **`plt.figure(figsize=(5, 5))`**：\n",
    "  - 创建一个大小为 5x5 英寸的绘图窗口。\n",
    "- **`plt.xlim((2.4, 3.8))`**：\n",
    "  - 设置横坐标的显示范围为 2.4 到 3.8。\n",
    "- **`plt.ylim((2.4, 3.8))`**：\n",
    "  - 设置纵坐标的显示范围为 2.4 到 3.8。\n",
    "\n",
    "---\n",
    "\n",
    "### 3. **提取特征值**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f40a499f",
   "metadata": {},
   "source": [
    "x_feature = list(map(lambda x: x[0], features))  # 返回每个数据的x特征值\n",
    "y_feature = list(map(lambda y: y[1], features))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c90821a",
   "metadata": {},
   "source": [
    "- **`features`**：\n",
    "  - 假设 `features` 是一个二维数组或列表，形如 `[[x1, y1], [x2, y2], ...]`，每个元素表示一个数据点的特征值。\n",
    "- **`map(lambda x: x[0], features)`**：\n",
    "  - 使用 `map` 和 `lambda` 提取 `features` 中每个数据点的第一个特征值（即横坐标）。\n",
    "  - 结果是一个迭代器，包含所有数据点的横坐标。\n",
    "- **`list(map(...))`**：\n",
    "  - 将 `map` 的结果转换为列表，存储在变量 `x_feature` 中。\n",
    "- **`map(lambda y: y[1], features)`**：\n",
    "  - 提取 `features` 中每个数据点的第二个特征值（即纵坐标），存储在变量 `y_feature` 中。\n",
    "\n",
    "---\n",
    "\n",
    "### 4. **绘制散点图**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa920b2a",
   "metadata": {},
   "source": [
    "plt.scatter(x_feature[:5], y_feature[:5], c=\"b\")  # 在画布上绘画出\"A\"类标签的数据点\n",
    "plt.scatter(x_feature[5:], y_feature[5:], c=\"g\")\n",
    "plt.scatter([3.18], [3.15], c=\"r\", marker=\"x\")  # 待测试点的坐标为 [3.18, 3.15]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f688153e",
   "metadata": {},
   "source": [
    "- **`plt.scatter(x_feature[:5], y_feature[:5], c=\"b\")`**：\n",
    "  - 绘制前 5 个数据点（假设属于 A 类）的散点，颜色为蓝色 (`\"b\"`)。\n",
    "- **`plt.scatter(x_feature[5:], y_feature[5:], c=\"g\")`**：\n",
    "  - 绘制后续数据点（假设属于 B 类）的散点，颜色为绿色 (`\"g\"`)。\n",
    "- **`plt.scatter([3.18], [3.15], c=\"r\", marker=\"x\")`**：\n",
    "  - 绘制一个红色 (`\"r\"`)的点，标记为 `x`，表示待测试点，坐标为 `[3.18, 3.15]`。\n",
    "\n",
    "---\n",
    "\n",
    "### 5. **`map` 和 `lambda` 表达式的用法**\n",
    "#### **`map` 的用法**\n",
    "`map` 是 Python 的内置函数，用于对可迭代对象中的每个元素应用指定的函数，并返回一个迭代器。\n",
    "\n",
    "**语法**：\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "953f8829",
   "metadata": {},
   "source": [
    "map(function, iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d9e4860",
   "metadata": {},
   "source": [
    "- **`function`**：要应用的函数。\n",
    "- **`iterable`**：要处理的可迭代对象（如列表、元组等）。\n",
    "\n",
    "**示例**：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "095af661",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [1, 2, 3, 4]\n",
    "squared = map(lambda x: x**2, nums)  # 对每个元素求平方\n",
    "print(list(squared))  # 输出：[1, 4, 9, 16]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39bfb9ac",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "#### **`lambda` 表达式的用法**\n",
    "`lambda` 是 Python 的匿名函数，用于定义简单的函数。\n",
    "\n",
    "**语法**：\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4231a6c4",
   "metadata": {},
   "source": [
    "lambda arguments: expression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "337f79b0",
   "metadata": {},
   "source": [
    "- **`arguments`**：函数的参数。\n",
    "- **`expression`**：返回值的表达式。\n",
    "\n",
    "**示例**：\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca896c2c",
   "metadata": {},
   "source": [
    "```python\n",
    "add = lambda x, y: x + y  # 定义一个匿名函数\n",
    "print(add(3, 5))  # 输出：8\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b517dfb",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "#### **结合使用 `map` 和 `lambda`**\n",
    "`map` 和 `lambda` 常结合使用，用于对列表或其他可迭代对象中的元素进行快速处理。\n",
    "\n",
    "**示例**：\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f133c16",
   "metadata": {},
   "source": [
    "```python\n",
    "nums = [1, 2, 3, 4]\n",
    "doubled = list(map(lambda x: x * 2, nums))  # 每个元素乘以 2\n",
    "print(doubled)  # 输出：[2, 4, 6, 8]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed4957df",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "---\n",
    "\n",
    "### 6. **总结**\n",
    "- 这段代码通过 `map` 和 `lambda` 提取了数据点的横纵坐标，并使用 Matplotlib 绘制了散点图。\n",
    "- **`map`**：用于对可迭代对象中的每个元素应用函数。\n",
    "- **`lambda`**：用于定义简单的匿名函数。\n",
    "- 最终的图像展示了两类数据点（蓝色和绿色）以及一个待测试点（红色 `x` 标记），便于直观分析数据分布。\n",
    "\n",
    "Similar code found with 1 license type"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ab98aa2",
   "metadata": {},
   "source": [
    "------**以上是上段代码的解释**------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10396cbb",
   "metadata": {},
   "source": [
    "由上图所示，标签为  $A$  （蓝色圆点）的数据在画布的左下角位置，而标签为  $B$  （绿色圆点）的数据在画布的右上角位置，通过图像可以清楚看出不同标签数据的分布情况。其中  红色 x 点  即表示本次实验需预测类别的测试数据。 \n",
    "\n",
    "##  12.6.  距离度量  # \n",
    "\n",
    "在计算两个样本间的相似度时，可以通过计算样本之间特征值的距离进行表示。若两个样本距离值越大（相距越远），则表示两个样本相似度低，相反，若两个样本值越小（相距越近），则表示两个样本相似度越高。 \n",
    "\n",
    "计算距离的方法有很多，本实验介绍两个最为常用的距离公式：曼哈顿距离 和 欧式距离。这两个距离的计算图示如下： \n",
    "\n",
    "![image](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710608422.jpg)\n",
    "\n",
    "##  12.7.  曼哈顿距离  # \n",
    "\n",
    "曼哈顿距离又称马氏距离，是计算距离最简单的方式之一。公式如下： \n",
    "\n",
    "$$d_{man}=\\sum_{i=1}^{N}\\left | X_{i}-Y_{i} \\right | $$ \n",
    "\n",
    "其中： \n",
    "\n",
    "  * $X$  ,  $Y$  ：两个数据点 \n",
    "\n",
    "  * $N$  ：每个数据中有  $N$  个特征值 \n",
    "\n",
    "  * $X_{i}$  ：数据  $X$  的第  $i$  个特征值 \n",
    "\n",
    "公式表示为将两个数据  $X$  和  $Y$  中每一个对应特征值之间差值的绝对值，再求和，便得到曼哈顿距离。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "87fb209b",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "def d_man(x, y):\n",
    "    d = np.sum(np.abs(x - y))\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "5a877789",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: [3.1 3.2]\n",
      "y: [2.5 2.8]\n",
      "1.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "x = np.array([3.1, 3.2])  # 任意指定 2 点计算\n",
    "print(\"x:\", x)\n",
    "\n",
    "y = np.array([2.5, 2.8])\n",
    "print(\"y:\", y)\n",
    "\n",
    "print(d_man(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bdc1918",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  12.8.  欧式距离  # \n",
    "\n",
    "欧式距离源自  $N$  维欧氏空间中两点之间的距离公式。表达式如下: \n",
    "\n",
    "$$d_{euc}= \\sqrt{\\sum_{i=1}^{N}(X_{i}-Y_{i})^{2}}$$ \n",
    "\n",
    "其中： \n",
    "\n",
    "  * $X$  ,  $Y$  ：两个数据点 \n",
    "\n",
    "  * $N$  ：每个数据中有  $N$  个特征值 \n",
    "\n",
    "  * $X_{i}$  ：数据  $X$  的第  $i$  个特征值 \n",
    "\n",
    "公式表示为将两个数据  $X$  和  $Y$  中的每一个对应特征值之间差值的平方，再求和，最后开平方，便是欧式距离。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "14d0613d",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "def d_euc(x, y):\n",
    "    d = np.sqrt(np.sum(np.square(x - y)))\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "6f2b0975",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: [0.76175757 0.77828589 0.60321605 0.48748046 0.17268626 0.74848503\n",
      " 0.65196478 0.70378424 0.56169254 0.42527185]\n",
      "y: [0.94210793 0.58602013 0.25054315 0.12307103 0.06435573 0.15079319\n",
      " 0.96462984 0.40029947 0.6239913  0.54677979]\n",
      "0.9508646538699733\n"
     ]
    }
   ],
   "source": [
    "x = np.random.random(10)  # 随机生成 10 个数的数组作为 x 特征的值\n",
    "print(\"x:\", x)\n",
    "\n",
    "y = np.random.random(10)\n",
    "print(\"y:\", y)\n",
    "\n",
    "distance_euc = d_euc(x, y)\n",
    "print(distance_euc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4392f1ab",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  12.9.  决策规则  # \n",
    "\n",
    "在得到测试样本和训练样本之间的相似度后，通过相似度的排名，可以得到每一个测试样本的 K 个相邻的训练样本，那如何通过 K 个邻居来判断测试样本的最终类别呢？可以根据数据特征对决策规则进行选取，不同的决策规则会产生不同的预测结果，最常用的决策规则是： \n",
    "\n",
    "  * 多数表决法：多数表决法类似于投票的过程，也就是在 K 个邻居中选择类别最多的种类作为测试样本的类别。 \n",
    "\n",
    "  * 加权表决法：根据距离的远近，对近邻的投票进行加权，距离越近则权重越大，通过权重计算结果最大值的类为测试样本的类别。 \n",
    "\n",
    "我们这里推荐使用多数表决法，这种方法更加简单，本次实验前面的配图即为多数表决法。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "49157ea4",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('C', 6), ('D', 5), ('A', 3), ('B', 2)]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import operator\n",
    "\n",
    "def majority_voting(class_count):\n",
    "    # 多数表决函数\n",
    "    sorted_class_count = sorted(\n",
    "        class_count.items(), key=operator.itemgetter(1), reverse=True\n",
    "    )\n",
    "    return sorted_class_count\n",
    "\n",
    "arr = {\"A\": 3, \"B\": 2, \"C\": 6, \"D\": 5}\n",
    "majority_voting(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1b1fc0c",
   "metadata": {},
   "source": [
    "在多数表决法的定义中，我们导入了 ` operater  ` 计算模块，目的是对字典类型结构排序。可以从结果中看出函数返回的结果为票数最多的 ` C  ` ，得票为 ` 6  ` 次。 \n",
    "\n",
    "##  12.10.  KNN 算法实现  # \n",
    "\n",
    "在学习完以上的各个步骤之后，KNN 算法也逐渐被勾勒出来。以下就是对 KNN 算法的完整实现，本次实验的距离计算采用欧式距离，分类的决策规则为多数表决法，定义函数 ` knn_classify()  ` ，其中函数的参数包括： \n",
    "\n",
    "  * ` test_data  ` ：用于分类的输入向量。 \n",
    "\n",
    "  * ` train_data  ` ：输入的训练样本集。 \n",
    "\n",
    "  * ` labels  ` ：样本数据的类标签向量。 \n",
    "\n",
    "  * ` k  ` ：用于选择最近邻居的数目。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "62d58bbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def knn_classify(test_data, train_data, labels, k):\n",
    "    # KNN 方法完整实现\n",
    "    distances = np.array([])  # 创建一个空的数组用于存放距离\n",
    "\n",
    "    for each_data in train_data:  # 使用欧式距离计算数据相似度\n",
    "        d = d_euc(test_data, each_data)\n",
    "        distances = np.append(distances, d)\n",
    "\n",
    "    sorted_distance_index = distances.argsort()  # 获取按距离从小到大排序后的索引\n",
    "    sorted_distance = np.sort(distances)\n",
    "    r = (sorted_distance[k] + sorted_distance[k - 1]) / 2  # 计算\n",
    "\n",
    "    class_count = {}\n",
    "    for i in range(k):  # 多数表决\n",
    "        vote_label = labels[sorted_distance_index[i]]\n",
    "        class_count[vote_label] = class_count.get(vote_label, 0) + 1\n",
    "\n",
    "    final_label = majority_voting(class_count)\n",
    "    return final_label, r"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d6c5761",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  12.11.  分类预测  # \n",
    "\n",
    "在实现 KNN 算法之后，接下来就可以对我们未知数据 ` [3.18,  3.15]  ` 开始分类,假定我们 K 值初始设定为 5，让我们看看分类的效果。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "9df219a2",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('B', 3), ('A', 2)]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data = np.array([3.18, 3.15])\n",
    "final_label, r = knn_classify(test_data, features, labels, 5)\n",
    "final_label"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b567e16b",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  12.12.  可视化展示  # \n",
    "\n",
    "在对数据 ` [3.18,  3.15]  ` 实现分类之后，接下来我们同样用画图的方式形象化展示 KNN 算法决策方式。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2df3f35c",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "def circle(r, a, b):  # 为了画出圆，这里采用极坐标的方式对圆进行表示 ：x=r*cosθ，y=r*sinθ。\n",
    "    theta = np.arange(0, 2 * np.pi, 0.01)\n",
    "    x = a + r * np.cos(theta)\n",
    "    y = b + r * np.sin(theta)\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "8476d2b9",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x15dfd966790>]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k_circle_x, k_circle_y = circle(r, 3.18, 3.15)\n",
    "\n",
    "plt.figure(figsize=(5, 5))\n",
    "plt.xlim((2.4, 3.8))\n",
    "plt.ylim((2.4, 3.8))\n",
    "\n",
    "x_feature = list(map(lambda x: x[0], features))  # 返回每个数据的 x 特征值\n",
    "y_feature = list(map(lambda y: y[1], features))\n",
    "\n",
    "plt.scatter(x_feature[:5], y_feature[:5], c=\"b\")  # 在画布上绘画出\"A\"类标签的数据点\n",
    "plt.scatter(x_feature[5:], y_feature[5:], c=\"g\")\n",
    "plt.scatter([3.18], [3.15], c=\"r\", marker=\"x\")  # 待测试点的坐标为 [3.1，3.2]\n",
    "plt.plot(k_circle_x, k_circle_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b477a0e",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "如图所示，当我们 K 值为 5 时，与测试样本距离最近的 5 个训练数据（如蓝色圆圈所示）中属于  $B$  类的有 3 个，属于  $A$  类的有 2 个，根据多数表决法决策出测试样本的数据为  $B$  类。 \n",
    "\n",
    "在 KNN 算法中，K 值的选择对数据的最终决策有很大的影响，下面我们引入 ` ipywidgets  ` 模块更加清晰的反映 K 的选择对预测结果影响。其中 ` ipywidgets  ` 模块是 ` jupyter  ` 中的一个交互式模块，可以通过下拉菜单选择不同的 K 值进行判断并预测未知点最后的种类。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "34737387",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "from ipywidgets import interact, fixed\n",
    "\n",
    "def change_k(test_data, features, k):\n",
    "    final_label, r = knn_classify(test_data, features, labels, k)\n",
    "    k_circle_x, k_circle_y = circle(r, 3.18, 3.15)\n",
    "\n",
    "    plt.figure(figsize=(5, 5))\n",
    "    plt.xlim((2.4, 3.8))\n",
    "    plt.ylim((2.4, 3.8))\n",
    "\n",
    "    x_feature = list(map(lambda x: x[0], features))  # 返回每个数据的 x 特征值\n",
    "    y_feature = list(map(lambda y: y[1], features))\n",
    "\n",
    "    plt.scatter(x_feature[:5], y_feature[:5], c=\"b\")  # 在画布上绘画出\"A\"类标签的数据点\n",
    "    plt.scatter(x_feature[5:], y_feature[5:], c=\"g\")\n",
    "    plt.scatter([3.18], [3.15], c=\"r\", marker=\"x\")  # 待测试点的坐标为 [3.1，3.2]\n",
    "    plt.plot(k_circle_x, k_circle_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "04e64e4c",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "14972891795c48709aa2722ae0c315c5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='k', options=(3, 5, 7, 9), value=3), Output()), _dom_classes=('widg…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.change_k(test_data, features, k)>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "interact(\n",
    "    change_k, test_data=fixed(test_data), features=fixed(features), k=[3, 5, 7, 9]\n",
    ")  # 可交互式绘图"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86eaea3",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "从图中可以直观的看到，不同的 K 值预测出不同的结果。接下来，我们使用 KNN 算法对真实数据集进行分类预测。 \n",
    "\n",
    "##  12.13.  加载数据集  # \n",
    "\n",
    "本次使用的数据集为丁香花数据集 ` course-9-syringa.csv  ` ，丁香花数据集包含 ` daphne  ` ， ` syringa  ` 和 ` willow  ` 等 ` 3  ` 个种类，其中每个种类包含 150 条数据，每条数据包含 4 个特征值：花萼长度，花萼宽度，花瓣长度，花瓣宽度。利用 Pandas 将其导入成 DataFrame 格式。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "3201f300",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (698325075.py, line 1)",
     "output_type": "error",
     "traceback": [
      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[51]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31mwget -nc https://cdn.aibydoing.com/aibydoing/files/course-9-syringa.csv\u001b[39m\n             ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "wget -nc https://cdn.aibydoing.com/aibydoing/files/course-9-syringa.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f9a2608",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>labels</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2.4</td>\n",
       "      <td>2.1</td>\n",
       "      <td>daphne</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.7</td>\n",
       "      <td>1.7</td>\n",
       "      <td>daphne</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>2.2</td>\n",
       "      <td>1.4</td>\n",
       "      <td>daphne</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.6</td>\n",
       "      <td>1.7</td>\n",
       "      <td>daphne</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>daphne</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width  labels\n",
       "0           5.1          3.5           2.4          2.1  daphne\n",
       "1           4.9          3.0           2.7          1.7  daphne\n",
       "2           4.7          3.2           2.2          1.4  daphne\n",
       "3           4.6          3.1           1.6          1.7  daphne\n",
       "4           5.0          3.6           1.6          1.4  daphne"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "lilac_data = pd.read_csv(\"../../data/course-9-syringa.csv\")\n",
    "lilac_data.head()  # 预览前 5 行"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce4ee659",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "  \n",
    "为了使我们对数据更加了解，同样我们用 ` plt  ` 将各个数据的特征绘制出来。由于丁香花数据集有 4 个特征值，在二维空间中无法直接表示，所以只有采用特征组合的方式绘画特征分布图。下面将 4 个特征，进行两两组合得到 6 种情况，并采用子图的方式进行绘制。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bff7e5a",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x15deaac3c10>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1000 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"绘制丁香花特征子图\n",
    "\"\"\"\n",
    "fig, axes = plt.subplots(2, 3, figsize=(20, 10))  # 构建生成 2*3 的画布，2 行 3 列\n",
    "fig.subplots_adjust(hspace=0.3, wspace=0.2)  # 定义每个画布内的行间隔和高间隔\n",
    "\n",
    "axes[0, 0].set_xlabel(\"sepal_length\")  # 定义 x 轴坐标值\n",
    "axes[0, 0].set_ylabel(\"sepal_width\")  # 定义 y 轴坐标值\n",
    "axes[0, 0].scatter(lilac_data.sepal_length[:50], lilac_data.sepal_width[:50], c=\"b\")\n",
    "axes[0, 0].scatter(\n",
    "    lilac_data.sepal_length[50:100], lilac_data.sepal_width[50:100], c=\"g\"\n",
    ")\n",
    "axes[0, 0].scatter(lilac_data.sepal_length[100:], lilac_data.sepal_width[100:], c=\"r\")\n",
    "axes[0, 0].legend([\"daphne\", \"syringa\", \"willow\"], loc=2)  # 定义示例\n",
    "\n",
    "axes[0, 1].set_xlabel(\"petal_length\")\n",
    "axes[0, 1].set_ylabel(\"petal_width\")\n",
    "axes[0, 1].scatter(lilac_data.petal_length[:50], lilac_data.petal_width[:50], c=\"b\")\n",
    "axes[0, 1].scatter(\n",
    "    lilac_data.petal_length[50:100], lilac_data.petal_width[50:100], c=\"g\"\n",
    ")\n",
    "axes[0, 1].scatter(lilac_data.petal_length[100:], lilac_data.petal_width[100:], c=\"r\")\n",
    "\n",
    "axes[0, 2].set_xlabel(\"sepal_length\")\n",
    "axes[0, 2].set_ylabel(\"petal_length\")\n",
    "axes[0, 2].scatter(lilac_data.sepal_length[:50], lilac_data.petal_length[:50], c=\"b\")\n",
    "axes[0, 2].scatter(\n",
    "    lilac_data.sepal_length[50:100], lilac_data.petal_length[50:100], c=\"g\"\n",
    ")\n",
    "axes[0, 2].scatter(lilac_data.sepal_length[100:], lilac_data.petal_length[100:], c=\"r\")\n",
    "\n",
    "axes[1, 0].set_xlabel(\"sepal_width\")\n",
    "axes[1, 0].set_ylabel(\"petal_width\")\n",
    "axes[1, 0].scatter(lilac_data.sepal_width[:50], lilac_data.petal_width[:50], c=\"b\")\n",
    "axes[1, 0].scatter(\n",
    "    lilac_data.sepal_width[50:100], lilac_data.petal_width[50:100], c=\"g\"\n",
    ")\n",
    "axes[1, 0].scatter(lilac_data.sepal_width[100:], lilac_data.petal_width[100:], c=\"r\")\n",
    "\n",
    "axes[1, 1].set_xlabel(\"sepal_length\")\n",
    "axes[1, 1].set_ylabel(\"petal_width\")\n",
    "axes[1, 1].scatter(lilac_data.sepal_length[:50], lilac_data.petal_width[:50], c=\"b\")\n",
    "axes[1, 1].scatter(\n",
    "    lilac_data.sepal_length[50:100], lilac_data.petal_width[50:100], c=\"g\"\n",
    ")\n",
    "axes[1, 1].scatter(lilac_data.sepal_length[100:], lilac_data.petal_width[100:], c=\"r\")\n",
    "\n",
    "axes[1, 2].set_xlabel(\"sepal_width\")\n",
    "axes[1, 2].set_ylabel(\"petal_length\")\n",
    "axes[1, 2].scatter(lilac_data.sepal_width[:50], lilac_data.petal_length[:50], c=\"b\")\n",
    "axes[1, 2].scatter(\n",
    "    lilac_data.sepal_width[50:100], lilac_data.petal_length[50:100], c=\"g\"\n",
    ")\n",
    "axes[1, 2].scatter(lilac_data.sepal_width[100:], lilac_data.petal_length[100:], c=\"r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "287ac835",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "由于该数据集与特征较多，所以通过特征组合的方式进行数据分布的展示。当遇到更多特征时，还可以通过数据特征降低维度的方式来进行数据分析，相应的方法会在后续课程中讲解。 \n",
    "\n",
    "##  12.14.  训练测试数据划分  # \n",
    "\n",
    "当得到一个数据集时，希望通过该数据集得到一个训练模型，我们常常将数据切分为两部分，一部分为训练集，一部分为测试集。根据经验，较好的切分方法为随机切分，切分比例为：70% 作为训练集，30% 作为测试集。 \n",
    "\n",
    "在此我们使用了 scikit-learn 模块的 ` train_test_split  ` 函数完成数据集切分。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "f89333c3",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'train_data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[52]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01msklearn\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mmodel_selection\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m train_test_split\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m X_train,X_test, y_train, y_test =train_test_split(\u001b[43mtrain_data\u001b[49m,train_target,test_size=\u001b[32m0.4\u001b[39m, random_state=\u001b[32m0\u001b[39m)\n",
      "\u001b[31mNameError\u001b[39m: name 'train_data' is not defined"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train,X_test, y_train, y_test =train_test_split(train_data,train_target,test_size=0.4, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6789775b",
   "metadata": {},
   "source": [
    "其中： \n",
    "\n",
    "  * ` X_train  ` , ` X_test  ` , ` y_train  ` , ` y_test  ` 分别表示，切分后的特征的训练集，特征的测试集，标签的训练集，标签的测试集；其中特征和标签的值是一一对应的。 \n",
    "\n",
    "  * ` train_data  ` , ` train_target  ` 分别表示为待划分的特征集和待划分的标签集。 \n",
    "\n",
    "  * ` test_size  ` ：测试样本所占比例。 \n",
    "\n",
    "  * ` random_state  ` ：随机数种子,在需要重复实验时，保证在随机数种子一样时能得到一组一样的随机数。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "8edd8283",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.4</td>\n",
       "      <td>2.5</td>\n",
       "      <td>1.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.6</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>113</th>\n",
       "      <td>5.1</td>\n",
       "      <td>2.5</td>\n",
       "      <td>4.6</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>4.8</td>\n",
       "      <td>3.0</td>\n",
       "      <td>2.2</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>4.8</td>\n",
       "      <td>3.4</td>\n",
       "      <td>2.1</td>\n",
       "      <td>2.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.3</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>108</th>\n",
       "      <td>5.7</td>\n",
       "      <td>2.5</td>\n",
       "      <td>4.1</td>\n",
       "      <td>2.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>128</th>\n",
       "      <td>5.9</td>\n",
       "      <td>2.8</td>\n",
       "      <td>4.1</td>\n",
       "      <td>2.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>4.8</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>5.3</td>\n",
       "      <td>3.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>4.4</td>\n",
       "      <td>3.2</td>\n",
       "      <td>2.1</td>\n",
       "      <td>1.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5.4</td>\n",
       "      <td>3.9</td>\n",
       "      <td>1.8</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85</th>\n",
       "      <td>6.0</td>\n",
       "      <td>3.4</td>\n",
       "      <td>4.5</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>54</th>\n",
       "      <td>6.5</td>\n",
       "      <td>2.8</td>\n",
       "      <td>4.6</td>\n",
       "      <td>2.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>4.5</td>\n",
       "      <td>2.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>1.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>5.7</td>\n",
       "      <td>2.9</td>\n",
       "      <td>4.2</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>144</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.3</td>\n",
       "      <td>4.9</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>89</th>\n",
       "      <td>5.5</td>\n",
       "      <td>2.5</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>77</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>2.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>6.4</td>\n",
       "      <td>2.9</td>\n",
       "      <td>4.3</td>\n",
       "      <td>1.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>115</th>\n",
       "      <td>6.3</td>\n",
       "      <td>3.2</td>\n",
       "      <td>4.2</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>94</th>\n",
       "      <td>5.6</td>\n",
       "      <td>2.7</td>\n",
       "      <td>4.2</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>87</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.3</td>\n",
       "      <td>4.4</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>2.4</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>2.2</td>\n",
       "      <td>1.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>127</th>\n",
       "      <td>6.1</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.8</td>\n",
       "      <td>3.1</td>\n",
       "      <td>2.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>125</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.2</td>\n",
       "      <td>5.7</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>126</th>\n",
       "      <td>5.3</td>\n",
       "      <td>2.8</td>\n",
       "      <td>4.3</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.3</td>\n",
       "      <td>2.1</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64</th>\n",
       "      <td>5.6</td>\n",
       "      <td>2.9</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>117</th>\n",
       "      <td>7.5</td>\n",
       "      <td>3.8</td>\n",
       "      <td>4.9</td>\n",
       "      <td>2.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>84</th>\n",
       "      <td>5.4</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.5</td>\n",
       "      <td>2.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>5.8</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.4</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>132</th>\n",
       "      <td>5.4</td>\n",
       "      <td>2.8</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>91</th>\n",
       "      <td>6.1</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.6</td>\n",
       "      <td>1.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>53</th>\n",
       "      <td>5.5</td>\n",
       "      <td>2.3</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>141</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.1</td>\n",
       "      <td>3.6</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78</th>\n",
       "      <td>6.0</td>\n",
       "      <td>2.9</td>\n",
       "      <td>4.5</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>6.2</td>\n",
       "      <td>2.9</td>\n",
       "      <td>4.3</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>143</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.2</td>\n",
       "      <td>4.5</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>93</th>\n",
       "      <td>5.0</td>\n",
       "      <td>2.3</td>\n",
       "      <td>3.3</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>4.8</td>\n",
       "      <td>3.4</td>\n",
       "      <td>2.2</td>\n",
       "      <td>1.7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal_length  sepal_width  petal_length  petal_width\n",
       "6             4.6          3.4           2.5          1.6\n",
       "3             4.6          3.1           1.6          1.7\n",
       "113           5.1          2.5           4.6          2.0\n",
       "12            4.8          3.0           2.2          1.5\n",
       "24            4.8          3.4           2.1          2.2\n",
       "129           6.2          3.0           4.0          1.6\n",
       "25            5.0          3.0           3.3          1.7\n",
       "108           5.7          2.5           4.1          2.8\n",
       "128           5.9          2.8           4.1          2.1\n",
       "45            4.8          3.0           1.9          1.5\n",
       "48            5.3          3.7           3.0          1.8\n",
       "42            4.4          3.2           2.1          1.3\n",
       "35            5.0          3.2           1.4          1.3\n",
       "5             5.4          3.9           1.8          1.5\n",
       "85            6.0          3.4           4.5          1.7\n",
       "54            6.5          2.8           4.6          2.4\n",
       "41            4.5          2.3           2.5          1.3\n",
       "96            5.7          2.9           4.2          2.3\n",
       "144           6.7          3.3           4.9          2.5\n",
       "89            5.5          2.5           4.0          2.2\n",
       "77            6.7          3.0           5.0          2.1\n",
       "74            6.4          2.9           4.3          1.9\n",
       "115           6.3          3.2           4.2          2.3\n",
       "94            5.6          2.7           4.2          1.5\n",
       "87            6.3          2.3           4.4          1.8\n",
       "29            4.7          3.2           2.4          1.7\n",
       "2             4.7          3.2           2.2          1.4\n",
       "127           6.1          3.0           3.5          1.8\n",
       "44            5.1          3.8           3.1          2.7\n",
       "125           6.5          3.2           5.7          1.8\n",
       "126           5.3          2.8           4.3          1.8\n",
       "23            5.1          3.3           2.1          2.0\n",
       "64            5.6          2.9           3.6          1.7\n",
       "117           7.5          3.8           4.9          2.2\n",
       "84            5.4          3.0           4.5          2.2\n",
       "14            5.8          4.0           2.4          1.5\n",
       "132           5.4          2.8           4.0          2.2\n",
       "91            6.1          3.0           4.6          1.4\n",
       "53            5.5          2.3           4.0          1.8\n",
       "141           6.7          3.1           3.6          2.3\n",
       "78            6.0          2.9           4.5          1.7\n",
       "97            6.2          2.9           4.3          2.3\n",
       "143           5.9          3.2           4.5          2.3\n",
       "93            5.0          2.3           3.3          1.8\n",
       "11            4.8          3.4           2.2          1.7"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# 得到 lilac 数据集中 feature 的全部序列: sepal_length,sepal_width,petal_length,petal_width\n",
    "feature_data = lilac_data.iloc[:, :-1]\n",
    "'''\n",
    "语法：\n",
    "DataFrame.iloc[行索引, 列索引]\n",
    "- 行索引：选择哪些行，使用整数索引或切片。\n",
    "- 列索引：选择哪些列，使用整数索引或切片。\n",
    "\n",
    " [:, :-1] 的含义\n",
    ":：表示选择所有行。\n",
    ":-1：表示选择从第 0 列到倒数第 2 列（不包括最后一列）的所有列。\n",
    ":-1 是 Python 切片的语法，表示从起始位置到倒数第 1 列之前。\n",
    "'''\n",
    "label_data = lilac_data[\"labels\"]  # 得到 lilac 数据集中 label 的序列\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    feature_data, label_data, test_size=0.3, random_state=2\n",
    ")\n",
    "\n",
    "X_test  # 输出 lilac_test 查看"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b8dab69",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "  \n",
    "##  12.15.  训练模型  # \n",
    "\n",
    "在之前实验部分我们已经通过 Python 按照流程实现 KNN 算法，在实战中，我们更常使用 scikit-learn 库中 KNN 函数实现数据的分类。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "237abec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "sklearn.neighbors.KNeighborsClassifier((n_neighbors=5, weights='uniform', algorithm='auto')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67685b72",
   "metadata": {},
   "source": [
    "这段代码是使用 `scikit-learn` 中的 `KNeighborsClassifier` 类来创建一个 **K-最近邻（K-Nearest Neighbors, KNN）分类器**。以下是详细解释以及参数的作用：\n",
    "\n",
    "---\n",
    "\n",
    "### 1. **`KNeighborsClassifier` 的作用**\n",
    "`KNeighborsClassifier` 是 `scikit-learn` 提供的一个分类器，用于实现 KNN 算法。KNN 是一种基于实例的学习算法，通过计算样本与训练集中数据点的距离，选择最近的 \\( k \\) 个邻居来进行分类。\n",
    "\n",
    "---\n",
    "\n",
    "### 2. **代码结构**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a373471",
   "metadata": {},
   "source": [
    "- **`KNeighborsClassifier`**：创建一个 KNN 分类器对象。\n",
    "- **`n_neighbors=5`**：设置 \\( k \\) 值，即选择最近的 5 个邻居。\n",
    "- **`weights='uniform'`**：设置权重策略，表示所有邻居的权重相同。\n",
    "- **`algorithm='auto'`**：设置用于计算最近邻的算法，`auto` 表示自动选择最优算法。\n",
    "\n",
    "---\n",
    "\n",
    "### 3. **参数解释**\n",
    "#### **1. `n_neighbors`**\n",
    "- **作用**：指定 \\( k \\) 值，即选择最近的邻居数量。\n",
    "- **默认值**：`5`。\n",
    "- **意义**：\n",
    "  - 如果 \\( k=1 \\)，分类结果完全由最近的一个邻居决定。\n",
    "  - 如果 \\( k>1 \\)，分类结果由最近的 \\( k \\) 个邻居的多数投票决定。\n",
    "- **示例**：\n",
    "  - `n_neighbors=3`：选择最近的 3 个邻居。\n",
    "\n",
    "---\n",
    "\n",
    "#### **2. `weights`**\n",
    "- **作用**：指定邻居的权重策略。\n",
    "- **可选值**：\n",
    "  - `'uniform'`（默认值）：所有邻居的权重相同（多数表决）。\n",
    "  - `'distance'`：根据距离分配权重，距离越近权重越大（加权表决）。\n",
    "  - 自定义函数：可以传入一个用户定义的函数，根据距离计算权重。\n",
    "- **意义**：\n",
    "  - `'uniform'`：简单多数投票。\n",
    "  - `'distance'`：更注重距离较近的邻居，适合数据分布不均匀的情况。\n",
    "\n",
    "---\n",
    "\n",
    "#### **3. `algorithm`**\n",
    "- **作用**：指定用于计算最近邻的算法。\n",
    "- **可选值**：\n",
    "  - `'auto'`（默认值）：根据数据的特性自动选择最优算法。\n",
    "  - `'ball_tree'`：使用 Ball Tree 数据结构。\n",
    "  - `'kd_tree'`：使用 KD Tree 数据结构。\n",
    "  - `'brute'`：使用暴力搜索。\n",
    "- **意义**：\n",
    "  - `'auto'` 是最常用的选项，`scikit-learn` 会根据数据的大小和维度自动选择合适的算法。\n",
    "\n",
    "---\n",
    "\n",
    "#### **4. 其他参数**\n",
    "- **`leaf_size`**：\n",
    "  - 用于 `BallTree` 或 `KDTree` 的叶节点大小。\n",
    "  - 默认值：`30`。\n",
    "  - 影响树的构建速度和查询速度。\n",
    "- **`metric`**：\n",
    "  - 用于计算距离的度量方法。\n",
    "  - 默认值：`'minkowski'`（闵可夫斯基距离）。\n",
    "  - 常用选项：\n",
    "    - `'euclidean'`：欧几里得距离。\n",
    "    - `'manhattan'`：曼哈顿距离。\n",
    "    - 自定义距离函数。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f6a0c40",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "---\n",
    "\n",
    "### 5. **总结**\n",
    "- **`KNeighborsClassifier`** 是用于实现 KNN 分类的工具类。\n",
    "- **主要参数**：\n",
    "  - `n_neighbors`：控制 \\( k \\) 值，决定选择多少个邻居。\n",
    "  - `weights`：控制邻居的权重分配方式。\n",
    "  - `algorithm`：控制最近邻计算的算法。\n",
    "- **常见用法**：\n",
    "  - 通过调整 \\( k \\) 值和权重策略，可以优化模型的性能。\n",
    "  - 使用 `auto` 算法让 `scikit-learn` 自动选择最优的计算方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b68a66fa",
   "metadata": {},
   "source": [
    "其中： \n",
    "\n",
    "  * ` n_neighbors  ` : ` k  ` 值，表示邻近个数，默认为 ` 5  ` 。 \n",
    "\n",
    "  * ` weights  ` : 决策规则选择，多数表决或加权表决，可用参数（ ` 'uniform'  ` , ` 'distance'  ` ） \n",
    "\n",
    "  * ` algorithm  ` : 搜索算法选择（ ` auto  ` ， ` kd_tree  ` , ` ball_tree  ` ），包括逐一搜索， ` kd  ` 树搜索或 ` ball  ` 树搜索 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d74222c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "def sklearn_classify(train_data, label_data, test_data, k_num):\n",
    "    # 使用 sklearn 构建 KNN 预测模型\n",
    "    knn = KNeighborsClassifier(n_neighbors=k_num)\n",
    "    # 训练数据集\n",
    "    knn.fit(train_data, label_data)\n",
    "    # 预测\n",
    "    predict_label = knn.predict(test_data)\n",
    "    # 返回预测值\n",
    "    return predict_label"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13c88eb0",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  12.16.  模型预测  # \n",
    "\n",
    "在上面定义函数之后，接下来就是对丁香花数据集中分出的测试集进行分类，传入 ` X_train  ` ， ` y_train  ` ， ` X_test  ` 以及 K 值 3，通过 KNN 算法分类后，输出测试集的分类结果。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "a3b001cc",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['daphne', 'daphne', 'willow ', 'daphne', 'daphne', 'willow ',\n",
       "       'daphne', 'syringa', 'willow ', 'daphne', 'daphne', 'daphne',\n",
       "       'daphne', 'daphne', 'syringa', 'syringa', 'syringa', 'willow ',\n",
       "       'syringa', 'willow ', 'syringa', 'willow ', 'willow ', 'syringa',\n",
       "       'syringa', 'daphne', 'daphne', 'willow ', 'daphne', 'willow ',\n",
       "       'willow ', 'daphne', 'syringa', 'willow ', 'willow ', 'daphne',\n",
       "       'willow ', 'willow ', 'syringa', 'willow ', 'willow ', 'willow ',\n",
       "       'willow ', 'syringa', 'daphne'], dtype=object)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用测试数据进行预测\n",
    "y_predict = sklearn_classify(X_train, y_train, X_test, 3)\n",
    "y_predict"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abdf3809",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  12.17.  准确率计算  # \n",
    "\n",
    "得到预测结果后，我们需要评估模型的表现，也就是得出模型预测的准确度。计算准确率就是比较预测值和真实值的差异，得到预测正确的样本数，将其除以测试集的总个数。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "1bcd6fb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_accuracy(test_labels, pred_labels):\n",
    "    # 准确率计算函数\n",
    "    correct = np.sum(test_labels == pred_labels)  # 计算预测正确的数据个数\n",
    "    n = len(test_labels)  # 总测试集数据个数\n",
    "    accur = correct / n\n",
    "    return accur"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71709c14",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "通过以上准确率计算函数，按照以下代码可以得到测试数据的分类准确率。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "d2d493e3",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.7777777777777778)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_accuracy(y_test, y_predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c149d9ee",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "##  12.18.  K 值选择  # \n",
    "\n",
    "当 K 值选取为 3 时，可以看到准确率不高，分类效果不太理想。 K 值的选取一直都是一个热门的话题，至今也没有得到很好的解决方法，根据经验，K 值的选择最好不超过样本数量的平方根。所以可以通过遍历的方式选择合适的 K 值。以下我们从 2 到 10 中画出每一个 K 值的准确率从而获得最佳 K 值。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "cbc73b0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "normal_accuracy = []  # 建立一个空的准确率列表\n",
    "k_value = range(2, 11)\n",
    "for k in k_value:\n",
    "    y_predict = sklearn_classify(X_train, y_train, X_test, k)\n",
    "    accuracy = get_accuracy(y_test, y_predict)\n",
    "    normal_accuracy.append(accuracy)\n",
    "\n",
    "plt.xlabel(\"k\")\n",
    "plt.ylabel(\"accuracy\")\n",
    "new_ticks = np.linspace(0.6, 0.9, 10)  # 设定 y 轴显示，从 0.6 到 0.9\n",
    "plt.yticks(new_ticks)\n",
    "plt.plot(k_value, normal_accuracy, c=\"r\")\n",
    "plt.grid(True)  # 给画布增加网格"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aa9e3c5",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "\n",
    "从图像中可以得到，当 K=4 和 K=6 时，模型准确率相当。但机器学习选择最优模型时，我们一般会考虑到模型的泛化能力，所以这里选择 K=4，也就是更简单的模型。 \n",
    "\n",
    "##  12.19.  Kd 树  # \n",
    "\n",
    "KNN 算法的易于理解，很大程度上由于在对 KNN 实现输入示例分类时所用方法是线性扫描，即输入示例与每一个训练示例做距离计算。正因如此，当数据量特别大时，这样的计算会非常耗时。为了提高 KNN 搜索效率，减少计算距离的次数，可以通过构建 Kd 树的方法提高计算效率。 \n",
    "\n",
    "Kd 树（英文：K-dimension tree）是一种对 K 维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。Kd 树是一种二叉树，表示对 K 维空间的一个划分，构造 Kd 树相当于不断地用垂直于坐标轴的超平面将 K 维空间切分，构成一系列的 K 维超矩形区域。Kd 树的每个结点对应于一个 K 维超矩形区域。利用 Kd 树可以省去对大部分数据点的搜索，从而减少搜索的计算量。 \n",
    "\n",
    "[ ![https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710608628.png](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710608628.png) ](https://cdn.aibydoing.com/aibydoing/images/document-uid214893labid6671timestamp1531710608628.png)\n",
    "\n",
    "##  12.20.  Kd 树最邻近搜索  # \n",
    "\n",
    "以下便是 Kd 树的最邻近搜索步骤： \n",
    "\n",
    "  * 从根节点开始，递归的往下移。往左还是往右的决定方法与插入元素的方法一样(如果输入点在分区面的左边则进入左子节点，在右边则进入右子节点)。 \n",
    "\n",
    "  * 一旦移动到叶节点，将该节点当作「目前最佳点」。 \n",
    "\n",
    "  * 解开递归，并对每个经过的节点运行下列步骤： \n",
    "\n",
    "    * 如果目前所在点比目前最佳点更靠近输入点，则将其变为目前最佳点。 \n",
    "\n",
    "    * 检查另一边子树有没有更近的点，如果有则从该节点往下找 \n",
    "\n",
    "  * 当根节点搜索完毕后完成最邻近搜索 \n",
    "\n",
    "通过步骤可以十分直观的发现，相比于传统 KNN 搜索遍历要节约很多时间和空间。 \n",
    "\n",
    "##  12.21.  Kd 树实现  # \n",
    "\n",
    "前面的讲解中，Kd 树的主要目的便是提高数据搜索的速度，减少内存和时间的消耗，以下我们就用代码来直观感受下 Kd 树的优点。采用 scikit-learn 库实现 Kd 树很简单，只需要在函数调用时传入 ` kd_tree  ` 参数即可。 \n",
    "\n",
    "实际上 scikit-learn 提供的方法已不再是普通的 KNN 实现，而是集成了多种优化搜索方法，所以这里无法对比采用和未采用 Kd 树搜索的时间。默认的 ` algorithm='auto'  ` 参数会自动选择优化搜索方法以减少训练用时。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ed5cf65",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [],
   "source": [
    "kd_x = np.random.random((100000, 2))  # 生成 10 万条测试数据\n",
    "kd_y = np.random.randint(4, size=(100000))\n",
    "\"\"\"\n",
    "np.random.randint(low, high=None, size=None, dtype=int)\n",
    "参数：\n",
    "- low：\n",
    "随机整数的下界（包括 low）。\n",
    "如果只提供一个参数，则表示随机整数的上界，默认下界为 0。\n",
    "- high：\n",
    "随机整数的上界（不包括 high）。\n",
    "如果未指定，则生成的随机数范围是 [0, low)。\n",
    "- size：\n",
    "指定生成随机整数的数量或形状。\n",
    "如果是一个整数，则表示生成一维数组的长度。\n",
    "如果是一个元组，则表示生成多维数组的形状。\n",
    "- dtype：\n",
    "指定生成的随机整数的数据类型，默认为 int。\n",
    "\"\"\"\n",
    "kd_knn = KNeighborsClassifier(n_neighbors=5, algorithm=\"kd_tree\")  # kd 树搜索"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "f10d3177",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 109 ms\n",
      "Wall time: 109 ms\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {\n",
       "  /* Definition of color scheme common for light and dark mode */\n",
       "  --sklearn-color-text: #000;\n",
       "  --sklearn-color-text-muted: #666;\n",
       "  --sklearn-color-line: gray;\n",
       "  /* Definition of color scheme for unfitted estimators */\n",
       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
       "  --sklearn-color-unfitted-level-3: chocolate;\n",
       "  /* Definition of color scheme for fitted estimators */\n",
       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
       "\n",
       "  /* Specific color for light theme */\n",
       "  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n",
       "  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-icon: #696969;\n",
       "\n",
       "  @media (prefers-color-scheme: dark) {\n",
       "    /* Redefinition of color scheme for dark theme */\n",
       "    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n",
       "    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-icon: #878787;\n",
       "  }\n",
       "}\n",
       "\n",
       "#sk-container-id-1 {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 pre {\n",
       "  padding: 0;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-hidden--visually {\n",
       "  border: 0;\n",
       "  clip: rect(1px 1px 1px 1px);\n",
       "  clip: rect(1px, 1px, 1px, 1px);\n",
       "  height: 1px;\n",
       "  margin: -1px;\n",
       "  overflow: hidden;\n",
       "  padding: 0;\n",
       "  position: absolute;\n",
       "  width: 1px;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-dashed-wrapped {\n",
       "  border: 1px dashed var(--sklearn-color-line);\n",
       "  margin: 0 0.4em 0.5em 0.4em;\n",
       "  box-sizing: border-box;\n",
       "  padding-bottom: 0.4em;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-container {\n",
       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
       "     so we also need the `!important` here to be able to override the\n",
       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
       "  display: inline-block !important;\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-text-repr-fallback {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       "div.sk-parallel-item,\n",
       "div.sk-serial,\n",
       "div.sk-item {\n",
       "  /* draw centered vertical line to link estimators */\n",
       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
       "  background-size: 2px 100%;\n",
       "  background-repeat: no-repeat;\n",
       "  background-position: center center;\n",
       "}\n",
       "\n",
       "/* Parallel-specific style estimator block */\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item::after {\n",
       "  content: \"\";\n",
       "  width: 100%;\n",
       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
       "  flex-grow: 1;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel {\n",
       "  display: flex;\n",
       "  align-items: stretch;\n",
       "  justify-content: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n",
       "  align-self: flex-end;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n",
       "  align-self: flex-start;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n",
       "  width: 0;\n",
       "}\n",
       "\n",
       "/* Serial-specific style estimator block */\n",
       "\n",
       "#sk-container-id-1 div.sk-serial {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "  align-items: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  padding-right: 1em;\n",
       "  padding-left: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
       "clickable and can be expanded/collapsed.\n",
       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
       "*/\n",
       "\n",
       "/* Pipeline and ColumnTransformer style (default) */\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable {\n",
       "  /* Default theme specific background. It is overwritten whether we have a\n",
       "  specific estimator or a Pipeline/ColumnTransformer */\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "/* Toggleable label */\n",
       "#sk-container-id-1 label.sk-toggleable__label {\n",
       "  cursor: pointer;\n",
       "  display: flex;\n",
       "  width: 100%;\n",
       "  margin-bottom: 0;\n",
       "  padding: 0.5em;\n",
       "  box-sizing: border-box;\n",
       "  text-align: center;\n",
       "  align-items: start;\n",
       "  justify-content: space-between;\n",
       "  gap: 0.5em;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label .caption {\n",
       "  font-size: 0.6rem;\n",
       "  font-weight: lighter;\n",
       "  color: var(--sklearn-color-text-muted);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n",
       "  /* Arrow on the left of the label */\n",
       "  content: \"▸\";\n",
       "  float: left;\n",
       "  margin-right: 0.25em;\n",
       "  color: var(--sklearn-color-icon);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "/* Toggleable content - dropdown */\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content {\n",
       "  max-height: 0;\n",
       "  max-width: 0;\n",
       "  overflow: hidden;\n",
       "  text-align: left;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content pre {\n",
       "  margin: 0.2em;\n",
       "  border-radius: 0.25em;\n",
       "  color: var(--sklearn-color-text);\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
       "  /* Expand drop-down */\n",
       "  max-height: 200px;\n",
       "  max-width: 100%;\n",
       "  overflow: auto;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
       "  content: \"▾\";\n",
       "}\n",
       "\n",
       "/* Pipeline/ColumnTransformer-specific style */\n",
       "\n",
       "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator-specific style */\n",
       "\n",
       "/* Colorize estimator box */\n",
       "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n",
       "#sk-container-id-1 div.sk-label label {\n",
       "  /* The background is the default theme color */\n",
       "  color: var(--sklearn-color-text-on-default-background);\n",
       "}\n",
       "\n",
       "/* On hover, darken the color of the background */\n",
       "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "/* Label box, darken color on hover, fitted */\n",
       "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator label */\n",
       "\n",
       "#sk-container-id-1 div.sk-label label {\n",
       "  font-family: monospace;\n",
       "  font-weight: bold;\n",
       "  display: inline-block;\n",
       "  line-height: 1.2em;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-label-container {\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "/* Estimator-specific */\n",
       "#sk-container-id-1 div.sk-estimator {\n",
       "  font-family: monospace;\n",
       "  border: 1px dotted var(--sklearn-color-border-box);\n",
       "  border-radius: 0.25em;\n",
       "  box-sizing: border-box;\n",
       "  margin-bottom: 0.5em;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "/* on hover */\n",
       "#sk-container-id-1 div.sk-estimator:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-1 div.sk-estimator.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
       "\n",
       "/* Common style for \"i\" and \"?\" */\n",
       "\n",
       ".sk-estimator-doc-link,\n",
       "a:link.sk-estimator-doc-link,\n",
       "a:visited.sk-estimator-doc-link {\n",
       "  float: right;\n",
       "  font-size: smaller;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1em;\n",
       "  height: 1em;\n",
       "  width: 1em;\n",
       "  text-decoration: none !important;\n",
       "  margin-left: 0.5em;\n",
       "  text-align: center;\n",
       "  /* unfitted */\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted,\n",
       "a:link.sk-estimator-doc-link.fitted,\n",
       "a:visited.sk-estimator-doc-link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "/* Span, style for the box shown on hovering the info icon */\n",
       ".sk-estimator-doc-link span {\n",
       "  display: none;\n",
       "  z-index: 9999;\n",
       "  position: relative;\n",
       "  font-weight: normal;\n",
       "  right: .2ex;\n",
       "  padding: .5ex;\n",
       "  margin: .5ex;\n",
       "  width: min-content;\n",
       "  min-width: 20ex;\n",
       "  max-width: 50ex;\n",
       "  color: var(--sklearn-color-text);\n",
       "  box-shadow: 2pt 2pt 4pt #999;\n",
       "  /* unfitted */\n",
       "  background: var(--sklearn-color-unfitted-level-0);\n",
       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted span {\n",
       "  /* fitted */\n",
       "  background: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link:hover span {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link {\n",
       "  float: right;\n",
       "  font-size: 1rem;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1rem;\n",
       "  height: 1rem;\n",
       "  width: 1rem;\n",
       "  text-decoration: none;\n",
       "  /* unfitted */\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "#sk-container-id-1 a.estimator_doc_link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>KNeighborsClassifier(algorithm=&#x27;kd_tree&#x27;)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>KNeighborsClassifier</div></div><div><a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.6/modules/generated/sklearn.neighbors.KNeighborsClassifier.html\">?<span>Documentation for KNeighborsClassifier</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></div></label><div class=\"sk-toggleable__content fitted\"><pre>KNeighborsClassifier(algorithm=&#x27;kd_tree&#x27;)</pre></div> </div></div></div></div>"
      ],
      "text/plain": [
       "KNeighborsClassifier(algorithm='kd_tree')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time kd_knn.fit(kd_x, kd_y)  # 输出 kd 树搜索训练用时"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be9dbb59",
   "metadata": {},
   "source": [
    "##  12.22.  总结  # \n",
    "\n",
    "本节实验中学习了 KNN 算法的原理及 Python 实现，以及采用 scikit-learn 库对 KNN 算法的实现，KNN 算法虽然原理逻辑简单，但是在很多分类或者回归的例子中表现的非常好。 \n",
    "\n",
    "相关链接 \n",
    "\n",
    "  * [ KNN 算法 - 维基百科 ](https://zh.wikipedia.org/wiki/%E6%9C%80%E8%BF%91%E9%84%B0%E5%B1%85%E6%B3%95)\n",
    "\n",
    "  * [ Kd 树 - 维基百科 ](https://zh.wikipedia.org/wiki/K-d%E6%A0%91)\n"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
